/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated July 28, 2023. Replaces all prior versions.
 *
 * Copyright (c) 2013-2023, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software or
 * otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
 * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

using System;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
#if UNITY_EDITOR
using System.Globalization;
using System.Text.RegularExpressions;
#endif

namespace Spine.Unity {

	public static class SkeletonDataCompatibility {

#if UNITY_EDITOR
		static readonly int[][] compatibleBinaryVersions = { new[] { 4, 2, 0 } };
		static readonly int[][] compatibleJsonVersions = { new[] { 4, 2, 0 } };

		static bool wasVersionDialogShown = false;
		static readonly Regex jsonVersionRegex = new Regex(@"""spine""\s*:\s*""([^""]+)""", RegexOptions.CultureInvariant);
#endif

		public enum SourceType {
			Json,
			Binary
		}

		[System.Serializable]
		public class VersionInfo {
			public string rawVersion = null;
			public int[] version = null;
			public SourceType sourceType;
		}

		[System.Serializable]
		public class CompatibilityProblemInfo {
			public VersionInfo actualVersion;
			public int[][] compatibleVersions;
			public string explicitProblemDescription = null;

			public string DescriptionString () {
				if (!string.IsNullOrEmpty(explicitProblemDescription))
					return explicitProblemDescription;

				string compatibleVersionString = "";
				string optionalOr = null;
				foreach (int[] version in compatibleVersions) {
					compatibleVersionString += string.Format("{0}{1}.{2}", optionalOr, version[0], version[1]);
					optionalOr = " or ";
				}
				return string.Format("Skeleton data could not be loaded. Data version: {0}. Required version: {1}.\nPlease re-export skeleton data with Spine {1} or change runtime to version {2}.{3}.",
					actualVersion.rawVersion, compatibleVersionString, actualVersion.version[0], actualVersion.version[1]);
			}
		}

#if UNITY_EDITOR
		public static VersionInfo GetVersionInfo (TextAsset asset, out bool isSpineSkeletonData, ref string problemDescription) {
			isSpineSkeletonData = false;
			if (asset == null)
				return null;

			VersionInfo fileVersion = new VersionInfo();
			bool hasBinaryExtension = asset.name.Contains(".skel");
			fileVersion.sourceType = hasBinaryExtension ? SourceType.Binary : SourceType.Json;

			bool isJsonFileByContent = IsJsonFile(asset);
			if (hasBinaryExtension == isJsonFileByContent) {
				if (hasBinaryExtension) {
					problemDescription = string.Format("Failed to read '{0}'. Extension is '.skel.bytes' but content looks like a '.json' file.\n"
						+ "Did you choose the wrong extension upon export?\n", asset.name);
				} else {
					problemDescription = string.Format("Failed to read '{0}'. Extension is '.json' but content looks like binary 'skel.bytes' file.\n"
						+ "Did you choose the wrong extension upon export?\n", asset.name);
				}
				isSpineSkeletonData = false;
				return null;
			}

			if (fileVersion.sourceType == SourceType.Binary) {
				try {
					using (MemoryStream memStream = new MemoryStream(asset.bytes)) {
						fileVersion.rawVersion = SkeletonBinary.GetVersionString(memStream);
					}
				} catch (System.Exception e) {
					problemDescription = string.Format("Failed to read '{0}'. It is likely not a binary Spine SkeletonData file.\n{1}", asset.name, e);
					isSpineSkeletonData = false;
					return null;
				}
			} else {
				Match match = jsonVersionRegex.Match(asset.text);
				if (match != null) {
					fileVersion.rawVersion = match.Groups[1].Value;
				} else {
					object obj = Json.Deserialize(new StringReader(asset.text));
					if (obj == null) {
						problemDescription = string.Format("'{0}' is not valid JSON.", asset.name);
						isSpineSkeletonData = false;
						return null;
					}

					Dictionary<string, object> root = obj as Dictionary<string, object>;
					if (root == null) {
						problemDescription = string.Format("'{0}' is not compatible JSON. Parser returned an incorrect type while parsing version info.", asset.name);
						isSpineSkeletonData = false;
						return null;
					}

					if (root.ContainsKey("skeleton")) {
						Dictionary<string, object> skeletonInfo = (Dictionary<string, object>)root["skeleton"];
						object jv;
						skeletonInfo.TryGetValue("spine", out jv);
						fileVersion.rawVersion = jv as string;
					}
				}
			}

			if (string.IsNullOrEmpty(fileVersion.rawVersion)) {
				// very likely not a Spine skeleton json file at all. Could be another valid json file, don't report errors.
				isSpineSkeletonData = false;
				return null;
			}

			string[] versionSplit = fileVersion.rawVersion.Split('.');
			try {
				fileVersion.version = new[]{ int.Parse(versionSplit[0], CultureInfo.InvariantCulture),
									int.Parse(versionSplit[1], CultureInfo.InvariantCulture) };
			} catch (System.Exception e) {
				problemDescription = string.Format("Failed to read version info at skeleton '{0}'. It is likely not a valid Spine SkeletonData file.\n{1}", asset.name, e);
				isSpineSkeletonData = false;
				return null;
			}
			isSpineSkeletonData = true;
			return fileVersion;
		}

		public static bool IsJsonFile (TextAsset file) {
			byte[] content = file.bytes;

			// check for binary skeleton version number string, starts after 8 byte hash
			char majorVersionChar = compatibleBinaryVersions[0][0].ToString()[0];
			if (content.Length > 10 && content[9] == majorVersionChar && content[10] == '.')
				return false;

			const int maxCharsToCheck = 256;
			int numCharsToCheck = Math.Min(content.Length, maxCharsToCheck);
			int i = 0;
			if (content.Length >= 3 && content[0] == 0xEF && content[1] == 0xBB && content[2] == 0xBF) // skip potential BOM
				i = 3;
			bool openingBraceFound = false;
			for (; i < numCharsToCheck; ++i) {
				char c = (char)content[i];
				if (char.IsWhiteSpace(c))
					continue;
				if (!openingBraceFound) {
					if (c == '{' || c == '[') openingBraceFound = true;
					else return false;
				} else if (c == '{' || c == '[' || c == ']' || c == '}' || c == ',')
					continue;
				else
					return c == '"';
			}
			return true;
		}

		public static CompatibilityProblemInfo GetCompatibilityProblemInfo (VersionInfo fileVersion) {
			if (fileVersion == null) {
				return null; // it's most likely not a Spine skeleton file, e.g. another json file. don't report problems.
			}

			CompatibilityProblemInfo info = new CompatibilityProblemInfo();
			info.actualVersion = fileVersion;
			info.compatibleVersions = (fileVersion.sourceType == SourceType.Binary) ? compatibleBinaryVersions
				: compatibleJsonVersions;

			foreach (int[] compatibleVersion in info.compatibleVersions) {
				bool majorMatch = fileVersion.version[0] == compatibleVersion[0];
				bool minorMatch = fileVersion.version[1] == compatibleVersion[1];
				if (majorMatch && minorMatch) {
					return null; // is compatible, thus no problem info returned
				}
			}
			return info;
		}

		public static void DisplayCompatibilityProblem (string descriptionString, TextAsset spineJson) {
			if (!wasVersionDialogShown) {
				wasVersionDialogShown = true;
				UnityEditor.EditorUtility.DisplayDialog("Version mismatch!", descriptionString, "OK");
			}
			Debug.LogError(string.Format("Error importing skeleton '{0}': {1}",
				spineJson.name, descriptionString), spineJson);
		}
#endif // UNITY_EDITOR
	}
}